home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / ici / ici.cpi / syscall.c < prev    next >
C/C++ Source or Header  |  1994-10-27  |  4KB  |  130 lines
  1. #include "fwd.h"
  2. #ifndef    NOSYSCALL
  3. #include "func.h"
  4. #include "op.h"
  5. #include "exec.h"
  6. #include <errno.h>
  7.  
  8. /*
  9.  * System calls.  We do all the easy ones because they cost so little,
  10.  * most of the code being in the kernel.  And who can tell what people
  11.  * will want anyway?
  12.  */
  13. extern int    access(), alarm(), acct(), alarm(), chdir(),
  14.         chmod(), chown(), chroot(), close(), creat(),
  15.         dup(), fork(), getpid(), getpgrp(),
  16.         getppid(), getuid(), geteuid(), getgid(), getegid(),
  17.         kill(), link(), lseek(), mkdir(), mknod(),
  18.         nice(), open(), pause(), rmdir(), setpgrp(),
  19.         setuid(), setgid(), setgid(), signal(), sync(),
  20.         ulimit(), umask(), umask(), unlink();
  21.  
  22. extern int    clock(), system(), lockf(), sleep();
  23.  
  24. STATIC int sys_ret();
  25.  
  26. STATIC int
  27. sys_simple()
  28. {
  29.     long    av[4];
  30.  
  31.     if (typecheck(CF_ARG2(), &av[0], &av[1], &av[2], &av[3]))
  32.     return 1;
  33.     return sys_ret((*CF_ARG1())(av[0], av[1], av[2], av[3]));
  34. }
  35.  
  36. STATIC int
  37. sys_ret(ret)
  38. int    ret;
  39. {
  40.     if (ret < 0)
  41.     {
  42.     error = syserr();
  43.     return 1;
  44.     }
  45.     return int_ret((long)ret);
  46. }
  47.  
  48.  
  49. cfunc_t    syscall_cfuncs[] =
  50. {
  51.     {CF_OBJ,    "access",    sys_simple,    access,        "si"},
  52.     {CF_OBJ,    "alarm",    sys_simple,    alarm,        "i"},
  53.     {CF_OBJ,    "acct",        sys_simple,    acct,        "s"},
  54.     {CF_OBJ,    "alarm",    sys_simple,    alarm,        "i"},
  55.     {CF_OBJ,    "chdir",    sys_simple,    chdir,        "s"},
  56.     {CF_OBJ,    "chmod",    sys_simple,    chmod,        "si"},
  57.     {CF_OBJ,    "chown",    sys_simple,    chown,        "sii"},
  58.     {CF_OBJ,    "chroot",    sys_simple,    chroot,        "s"},
  59.     {CF_OBJ,    "_close",    sys_simple,    close,        "i"},
  60.     {CF_OBJ,    "creat",    sys_simple,    creat,        "si"},
  61.     {CF_OBJ,    "dup",        sys_simple,    dup,        "i"},
  62.     /*### exec */
  63.     /*### fcntl */
  64.     {CF_OBJ,    "_exit",    sys_simple,    (int(*)()) exit,"i"},
  65.     {CF_OBJ,    "fork",        sys_simple,    fork,        ""},
  66.     {CF_OBJ,    "getpid",    sys_simple,    getpid,        ""},
  67.     {CF_OBJ,    "getpgrp",    sys_simple,    getpgrp,    ""},
  68.     {CF_OBJ,    "getppid",    sys_simple,    getppid,    ""},
  69.     {CF_OBJ,    "getuid",    sys_simple,    getuid,        ""},
  70.     {CF_OBJ,    "geteuid",    sys_simple,    geteuid,    ""},
  71.     {CF_OBJ,    "getgid",    sys_simple,    getgid,        ""},
  72.     {CF_OBJ,    "getegid",    sys_simple,    getegid,    ""},
  73.     /*### fcntl */
  74.     {CF_OBJ,    "kill",        sys_simple,    kill,        "ii"},
  75.     {CF_OBJ,    "link",        sys_simple,    link,        "ss"},
  76.     {CF_OBJ,    "lseek",    sys_simple,    lseek,        "iii"},
  77.     {CF_OBJ,    "mkdir",    sys_simple,    mkdir,        "si"},
  78.     {CF_OBJ,    "mknod",    sys_simple,    mknod,        "sii"},
  79.     {CF_OBJ,    "nice",        sys_simple,    nice,        "i"},
  80.     {CF_OBJ,    "open",        sys_simple,    open,        "sii"},
  81.     {CF_OBJ,    "pause",    sys_simple,    pause,        ""},
  82.     /* ### pipe */
  83.     /* ### poll */
  84.     /* ### read */
  85.     {CF_OBJ,    "rmdir",    sys_simple,    rmdir,        "s"},
  86.     {CF_OBJ,    "setpgrp",    sys_simple,    setpgrp,    ""},
  87.     {CF_OBJ,    "setuid",    sys_simple,    setuid,        "i"},
  88.     {CF_OBJ,    "setgid",    sys_simple,    setgid,        "i"},
  89.     {CF_OBJ,    "setgid",    sys_simple,    setgid,        "i"},
  90.     {CF_OBJ,    "signal",    sys_simple,    signal,        "ii"},
  91.     /* ### stat */
  92.     {CF_OBJ,    "sync",        sys_simple,    sync,        ""},
  93.     /* ### times */
  94. #ifndef NeXT
  95.     {CF_OBJ,    "ulimit",    sys_simple,    ulimit,        "ii"},
  96. #endif
  97.     {CF_OBJ,    "umask",    sys_simple,    umask,        "i"},
  98.     {CF_OBJ,    "umask",    sys_simple,    umask,        "i"},
  99.     /* ### uname */
  100.     {CF_OBJ,    "unlink",    sys_simple,    unlink,        "s"},
  101.     /* ### utime */
  102.     /* ### wait */
  103.     /* ### write */
  104.     /*
  105.      * Non system calls, but they act so similar.
  106.      */
  107.     {CF_OBJ,    "clock",    sys_simple,    clock,        ""},
  108.     {CF_OBJ,    "system",    sys_simple,    system,        "s"},
  109.     {CF_OBJ,    "lockf",    sys_simple,    lockf,        "iii"},
  110.     {CF_OBJ,    "sleep",    sys_simple,    sleep,        "i"},
  111.     {CF_OBJ}
  112. };
  113.  
  114. #if 0
  115. f_unixfuncs()
  116. {
  117.     if (def_cfuncs(syscall_cfuncs))
  118.     return 1;
  119.     return loose_ret(objof(&o_null));
  120. }
  121.  
  122. cfunc_t    unix_cfuncs[] =
  123. {
  124.     {CF_OBJ,    "unixfuncs",    f_unixfuncs},
  125.     {CF_OBJ}
  126. };
  127. #endif
  128.  
  129. #endif /*NOSYSCALL*/
  130.